﻿#define _CRT_SECURE_NO_WARNINGS 1
#pragma warning(disable:4996)
#include<iostream>
#include<string>
using namespace std;
#if 0
/*1、建立一个时钟类Clock，具有三个私有成员变量hour、minute、second，用来保存时，分，秒数据，
     和如下几个函数：
（1）构造函数将时、分、秒都设置为0；
（2）提取运算符重载友元函数和插入运算符重载友元函数，分别用于输入时钟信息和打印时钟信息；
（3）编写主函数：创建一个时钟对象，先输入该时钟信息，然后显示时钟信息。
*/
class Clock {
    friend istream& operator>>(istream& in, Clock& c);
    friend ostream& operator<<(ostream& out, Clock& c);
private:
    int hour;
    int minute;
    int second;
public:
    Clock() {
        hour = 0;
        minute = 0;
        second = 0;
    }
};
istream& operator>>(istream& in, Clock& c) {
    in >> c.hour >> c.minute >> c.second;
    return in;
}
ostream& operator<<(ostream& out, Clock& c) {
    cout << c.hour << "：" << c.minute << "：" << c.second;
    return out;
}
int main(){
    
    Clock c;
    cin >> c;
    cout << c;
    return 0;
}
#endif

#if 0
/*2、定义三个类Geometry、Cuboid和Sphere分别表示几何体、长方体和球体，其中类Geometry是类Cuboid和Sphere的基类。按下述要求编程：
（1）几何体Geometry具有保护型成员变量type，用于存放几何体的类型，构造函数Geometry(char *t)、
     析构函数和计算体积的纯虚函数computeVolume；
（2）长方体Cuboid派生于Geometry，具有三个成员变量：长（length）、宽（width）、高（height），
     构造函数Cuboid(char *t, double l,double w, double h)和计算长方体体积的覆盖函数computeVolume；
（3）球体Sphere也派生于Geometry，具有一个成员变量半径（radius），
     构造函数Sphere(char *t, double r)和计算球体体积的覆盖函数computeVolume；
（4）编写主函数：创建一个Cuboid对象和Sphere对象，然后通过Geometry类型的指针，分别调用创建对象的computeVolume函数，打印其体积。
*/
class Geometry {
public:
    Geometry(const char* t){
        type = new char [strlen(t) + 1];
        strcpy(type, t);
    }
    // 析构函数  
    ~Geometry() {
        delete[] type;
    }
    // 纯虚函数，计算体积  
    virtual double computeVolume() = 0;
    // 显示类型  
    void showType(){
        cout << "Type: " << type << endl;
    }
protected:
    char* type;
};
class Cuboid:public Geometry {
public:
    Cuboid(const char* t, double l, double w, double h):Geometry(t),length(l),width(w),height(h){}
    double computeVolume() {
        return length * width * height;
    }
private:
    double length;
    double width;
    double height;
};
class Sphere :public Geometry {
public:
    Sphere(const char* t, double r) :Geometry(t), radius(r){}
    double computeVolume(){
        const double pi = 3.14159;
        return (4.0 / 3.0) * pi * radius * radius * radius;
    } 
private:
    double radius;
};
int main() {
     // 创建长方体对象  
    Cuboid cuboid("Cuboid", 5.0, 3.0, 4.0);
    // 创建球体对象  
    Sphere sphere("Sphere", 2.5);

    // 通过Geometry类型的指针调用computeVolume函数  
    Geometry* geomPtr1 = &cuboid;
    Geometry* geomPtr2 = &sphere;

    // 显示类型并计算体积  
    geomPtr1->showType();
    cout << "Volume: " << geomPtr1->computeVolume() << endl;

    geomPtr2->showType();
    cout << "Volume: " << geomPtr2->computeVolume() << endl;

    return 0;
}
#endif

class Employee {
public:
    //构造函数
    Employee(const char* _name) {
        name = new char[strlen(_name) + 1];
        strcpy(name, _name);
    }
    //析构函数
    ~Employee() {
        delete[] name;
    }
    virtual double computePay() = 0;
protected:
    char* name;
};
class Wage :public Employee {
public:
    Wage(const char* _name, double _wage, double _hours) :Employee(_name), wage(_wage), hours(_hours) {}
    double computePay() {
        return wage * hours;
    }
protected:
    double wage;
    double hours;
};
class Sales :public Wage{
public:
    Sales(const char* _name, double _wage, double _hours, double _sale, double _comm):
        Wage(_name, _wage, _hours), sale(_sale), comm(_comm) {}
    double computePay(){
        return wage * hours + sale * comm;
    }
protected:
    double sale;
    double comm;
};
int main() {
    
    Wage w0("w0",100.0, 200.0);
    Sales s0("s0",100,180,2000,0.2);
    Employee* p;
    p = &w0;
    cout << "w0=" << p->computePay() << endl;
    p = &s0;
    cout << "s0=" << p->computePay() << endl;
    return 0;
}